﻿using System;
using System.ComponentModel;
using System.Linq;
using System.Windows.Annotations;
using System.Xml.Linq;
using RiskMan.Config;
using RiskMan.DataClass;
using RiskMan.DataClass.BaseTransaqCalss;
using RiskMan.DataClass.Gerchik;
using System.Windows.Media;

namespace RiskMan.Views.Robot
{
    public delegate void ShowMassege(string message);
    /// <summary>
    /// Логика основного алгоритма робота
    /// </summary>
    class LogikGerchikRobot
    {
        private Data data;
        private readonly MainWindow _mainWindow;
        int _accuraccy;
        readonly ShowMassege _method;
        private static int _diffTime = 1000000;
        private static DateTime _tmpdateTime = DateTime.Now;
        private MediaPlayer player = new MediaPlayer();
        private GechikRobotItem gItemTmp;
        //private static double prevCurOpen;
        
        #region Constructors

        public LogikGerchikRobot()
        { }

        public LogikGerchikRobot(Data data)
        {
            this.data = data;
            this._method = MainWindow.StaticLevel.Method;
            if (_diffTime == 1000000)
                try
                {
                    _diffTime = Convert.ToInt32((XElement.Parse(MainWindow.OConn.SendCommand(data.TransaqCommand.GetServtimeDifference()))).LastAttribute.Value);
                }
                catch
                {

                }
        }
        //public LogikGerchikRobot(Data data, MainWindow mainWindow, ShowMassege method)
        //{
        //    this.data = data;
        //    _mainWindow = mainWindow;
        //    this._method = method;
        //    if (_diffTime == 1000000)
        //        try
        //        {
        //            _diffTime = Convert.ToInt32((XElement.Parse(MainWindow.OConn.SendCommand(data.TransaqCommand.GetServtimeDifference()))).LastAttribute.Value);
        //        }
        //        catch
        //        {

        //        }


        //}
        #endregion

        public void Start(GechikRobotItem grItem)
        {
            gItemTmp = grItem;
            if (grItem.TypeRobot == Cfg.TypeGerchikSovetnik)
            {
                Sovetnik sov = new Sovetnik();
                sov.Start(grItem);
                return;
            }

            if (MainWindow.Login != "FZTC226A" && MainWindow.Login != "FZTC184A" && MainWindow.Login != "IVAN14108")
                return;
            data.GetBoard(grItem.Instrument);
            //цена последней сделки
            grItem.LastPrice = data.GetLastPrice(grItem.Instrument);
            _accuraccy = data.GetAccuraccy(grItem.Instrument);
            if (_diffTime == 1000000)
                return;

            TimeSpan curTime = DateTime.Now.TimeOfDay - TimeConvertor(_diffTime);

            //обрабатываем заявки до начала торгов
            grItem.CurPosition = 0; //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! не забыть поменять на 0 после проверки стопов
            if (grItem.TradeList != null)
                if (grItem.TradeList.Count > 0)
                {
                    GetStatusAndBalance(grItem);
                    GetStatusAndBalanceStopLimit(grItem);
                    foreach (var item in grItem.TradeList)
                    {
                        if (item.OpenBalance != 0)
                        {
                            grItem.CurPosition = grItem.CurPosition + item.OpenBalance + item.CloseBalance +
                                                 item.OrderFromStopLimitCloseQuantity;
                            if (!grItem.AddCurrentAttempt)
                            {
                                grItem.CurrentAttempt = grItem.CurrentAttempt + 1;
                                grItem.AddCurrentAttempt = true;
                            }
                        }
                    }
                }

            //снятие стоп-заявок, если позиция равна нулю
            if (grItem.CurPosition == 0 && grItem.TradeList.Count > 0)
            {
                var stopLimitMassiv = data.GetStopOrderListAllforInstrunemtsActive(grItem.Account, grItem.ClientCode, grItem.Instrument);
                if (stopLimitMassiv.Count > 0 && grItem.TradeList.Count > 0)
                {
                    foreach (var stopItem in stopLimitMassiv)
                    {
                        if (stopItem.Transactionid == grItem.TradeList[0].StopLimitCloseID)
                        {
                            MainWindow.OConn.SendCommand(
                                data.TransaqCommand.CancelStopOrder(grItem.TradeList[0].StopLimitCloseID));
                            _method(
                                string.Format("Снятие стоп-заявки при нулевой позиции"));
                            grItem.TradeList.Remove(grItem.TradeList[0]);
                            break;
                        }
                    }
                }
            }

            //Логика просчета свечей и определение возомжности входа в позицию
            foreach (var item in data.CandlesItems)
            {


                int curCandle = item.Candle.Count - 1;
                int thirdCandle = item.Candle.Count - 2;
                int secondCandle = item.Candle.Count - 3;
                int firstCandle = item.Candle.Count - 4;
                if (item.Seccode == grItem.Instrument &&
                    MainWindow.DictionaryTimeFrame.FirstOrDefault(x => x.Value == grItem.TimeFrame).Key == item.Period)
                {
                    for (int i = item.Candle.Count - 2; i >= 3; i--)
                    {
                        if (Math.Abs(grItem.PrevCurOpen - item.Candle[curCandle].Open) > 0.000001)
                        {
                            _method(
                                string.Format(
                                    "Инструмент: {7}   .Время: {6}     . Время третьей свечи {0} , Low={1}, Время второй свечи {2} , Low={3}, Время первой свечи {4} , Low={5} "
                                    , item.Candle[thirdCandle].DateTime, item.Candle[thirdCandle].Low,
                                    item.Candle[secondCandle].DateTime, item.Candle[secondCandle].Low,
                                    item.Candle[firstCandle].DateTime, item.Candle[firstCandle].Low,
                                    item.Candle[curCandle].DateTime.TimeOfDay, grItem.Instrument));
                            grItem.PrevCurOpen = item.Candle[curCandle].Open;

                        }
                        //if (item.Candle[curCandle].DateTime.Date > new DateTime(2014, 8, 16))
                        //    return;

                        if (item.Candle[curCandle].DateTime.Date == DateTime.Now.Date &&
                            item.Candle[i - 2].DateTime.Date == DateTime.Now.Date &&
                            item.Candle[thirdCandle].DateTime.Date == DateTime.Now.Date)
                        {

                            if (grItem.LastDateTimeCandel !=
                                new DateTime(item.Candle[curCandle].DateTime.Year, item.Candle[curCandle].DateTime.Month,
                                    item.Candle[curCandle].DateTime.Day,
                                    item.Candle[curCandle].DateTime.Hour, item.Candle[curCandle].DateTime.Minute, 0))
                            {
                                if (grItem.CurrentAttempt < grItem.AttemptAmount &&
                                    grItem.TimeAttemptOpenPoz.TimeOfDay != item.Candle[thirdCandle].DateTime.TimeOfDay)
                                    if (!grItem.ReapetEnterOnLevel ||
                                        (grItem.ReapetEnterOnLevel &&
                                         !grItem.ListLevel.Contains(item.Candle[thirdCandle].Low) &&
                                         !grItem.ListLevel.Contains(item.Candle[thirdCandle].High)))
                                    {
                                        #region Открытие позиции

                                        if (item.Candle[curCandle].DateTime.TimeOfDay <= grItem.TimeStopLevel.TimeOfDay &&
                                            (item.Candle[curCandle].DateTime.TimeOfDay < grItem.TimeClosePoz.TimeOfDay ||
                                             grItem.TimeClosePoz.TimeOfDay == new TimeSpan(0, 0, 0)) &&
                                            item.Candle[firstCandle].DateTime.TimeOfDay >
                                            grItem.TimeStartLevel.TimeOfDay)
                                        {
                                            if (!grItem.CommentForFirstCandle)
                                            {
                                                _method(
                                                    string.Format(
                                                        "Начало работы робота. Инструмент: {7}   .Время: {6}     . Время третьей свечи {0} , Low={1}, Время второй свечи {2} , Low={3}, Время первой свечи {4} , Low={5} "
                                                        , item.Candle[thirdCandle].DateTime,
                                                        item.Candle[thirdCandle].Low,
                                                        item.Candle[secondCandle].DateTime,
                                                        item.Candle[secondCandle].Low,
                                                        item.Candle[firstCandle].DateTime, item.Candle[firstCandle].Low,
                                                        item.Candle[curCandle].DateTime.TimeOfDay, grItem.Instrument));
                                                grItem.PrevCurOpen = item.Candle[curCandle].Open;

                                                grItem.CommentForFirstCandle = true;
                                            }
                                            //if (grItem.TradeList.Count == 0)
                                            //{
                                            //    if (!grItem.ReapetEnterOnLevel ||
                                            //        (grItem.ReapetEnterOnLevel && !grItem.ListLevel.Contains(200) &&
                                            //         !grItem.ListLevel.Contains(item.Candle[thirdCandle].High)))
                                            //    {

                                            //        AddOrderOpenTotradeList(grItem, 70, 'S', true);

                                            //    }

                                            //    grItem.ListLevel.Add(200);
                                            //}
                                            //Открытие позиций
                                            if (_tmpdateTime.TimeOfDay + new TimeSpan(0, 0, 10) <=
                                                DateTime.Now.TimeOfDay)

                                                if (grItem.TradeList != null &&
                                                    (grItem.CurPosition == 0 && grItem.TradeList.Count == 0))
                                                {
                                                    #region Pattern #1

                                                    //Условия для входа в лонг
                                                    if (grItem.Patterns.Contains(Cfg.Pattern1Long))
                                                        if (item.Candle[thirdCandle].Low >=
                                                            item.Candle[secondCandle].Low &&
                                                            item.Candle[thirdCandle].Low <=
                                                            item.Candle[secondCandle].Low + grItem.ThirdBarDeviation &&
                                                            Math.Abs(item.Candle[secondCandle].Low -
                                                                     item.Candle[firstCandle].Low) < 0.000001)
                                                        {
                                                            _method(
                                                                string.Format(
                                                                    "Условия для входа в лонг по паттерну №1. Время третьей свечи {0} , Low={1}, Время второй свечи {2} , Low={3}, Время первой свечи {4} , Low={5} "
                                                                    , item.Candle[thirdCandle].DateTime,
                                                                    item.Candle[thirdCandle].Low,
                                                                    item.Candle[secondCandle].DateTime,
                                                                    item.Candle[secondCandle].Low,
                                                                    item.Candle[firstCandle].DateTime,
                                                                    item.Candle[firstCandle].Low));

                                                            LimitOrMarketOrderForOpenPosition(grItem,
                                                                item.Candle[curCandle].Open,
                                                                item.Candle[secondCandle].Low,
                                                                Cfg.Buy);
                                                            TimeOpenFix(grItem, item, curCandle);
                                                            grItem.ListLevel.Add(item.Candle[thirdCandle].Low);
                                                            grItem.TimeAttemptOpenPoz =
                                                                item.Candle[thirdCandle].DateTime;
                                                            if (!String.IsNullOrEmpty(Properties.Settings.Default.SoundOpenPoz))
                                                                PlaySound(Properties.Settings.Default.SoundOpenPoz);
                                                            return;
                                                        }

                                                    //Условия для входа в шорт
                                                    if (grItem.Patterns.Contains(Cfg.Pattern1Short))
                                                        if (item.Candle[thirdCandle].High <=
                                                            item.Candle[secondCandle].High &&
                                                            item.Candle[thirdCandle].High >=
                                                            item.Candle[secondCandle].High - grItem.ThirdBarDeviation &&
                                                            Math.Abs(item.Candle[secondCandle].High -
                                                                     item.Candle[firstCandle].High) < 0.000001)
                                                        {
                                                            _method(
                                                                string.Format(
                                                                    "Условия для входа в шорт по паттерну №1. Время третьей свечи {0} , High={1}, Время второй свечи {2} , High={3}, Время первой свечи {4} , High={5} "
                                                                    , item.Candle[thirdCandle].DateTime,
                                                                    item.Candle[thirdCandle].High,
                                                                    item.Candle[secondCandle].DateTime,
                                                                    item.Candle[secondCandle].High,
                                                                    item.Candle[firstCandle].DateTime,
                                                                    item.Candle[firstCandle].High));

                                                            LimitOrMarketOrderForOpenPosition(grItem,
                                                                item.Candle[curCandle].Open,
                                                                item.Candle[secondCandle].High,
                                                                Cfg.Sell);
                                                            TimeOpenFix(grItem, item, curCandle);
                                                            grItem.ListLevel.Add(item.Candle[thirdCandle].High);
                                                            grItem.TimeAttemptOpenPoz =
                                                                item.Candle[thirdCandle].DateTime;
                                                            if (!String.IsNullOrEmpty(Properties.Settings.Default.SoundOpenPoz))
                                                                PlaySound(Properties.Settings.Default.SoundOpenPoz);
                                                            return;
                                                        }

                                                    #endregion

                                                    #region Pattern #2

                                                    #region Вариация №1 (2и3 отдельно от 1)

                                                    //Условия для входа в лонг
                                                    if (grItem.Patterns.Contains(Cfg.Pattern21Long))
                                                        if (item.Candle[i - 2].DateTime.TimeOfDay >
                                                            grItem.TimeStartLevel.TimeOfDay)
                                                            if (item.Candle[thirdCandle].Low >=
                                                                item.Candle[secondCandle].Low &&
                                                                item.Candle[thirdCandle].Low <=
                                                                item.Candle[secondCandle].Low + grItem.ThirdBarDeviation &&
                                                                Math.Abs(item.Candle[secondCandle].Low -
                                                                         item.Candle[i - 2].Low) < 0.000001)
                                                            {
                                                                _method(
                                                                    string.Format(
                                                                        "Условия для входа в лонг по паттерну №2 (2и3 low отдельно от 1). Время третьей свечи {0} , Low={1}, Время второй свечи {2} , Low={3}, Время первой свечи {4} , Low={5} "
                                                                        , item.Candle[thirdCandle].DateTime,
                                                                        item.Candle[thirdCandle].Low,
                                                                        item.Candle[secondCandle].DateTime,
                                                                        item.Candle[secondCandle].Low,
                                                                        item.Candle[i - 2].DateTime,
                                                                        item.Candle[i - 2].Low));
                                                                LimitOrMarketOrderForOpenPosition(grItem,
                                                                    item.Candle[curCandle].Open,
                                                                    item.Candle[secondCandle].Low,
                                                                    Cfg.Buy);
                                                                TimeOpenFix(grItem, item, curCandle);
                                                                grItem.ListLevel.Add(item.Candle[thirdCandle].Low);
                                                                grItem.TimeAttemptOpenPoz =
                                                                    item.Candle[thirdCandle].DateTime;
                                                                if (!String.IsNullOrEmpty(Properties.Settings.Default.SoundOpenPoz))
                                                                    PlaySound(Properties.Settings.Default.SoundOpenPoz);
                                                                return;

                                                            }

                                                    //Условия для входа в шорт
                                                    if (grItem.Patterns.Contains(Cfg.Pattern21Short))
                                                        if (item.Candle[i - 2].DateTime.TimeOfDay >
                                                            grItem.TimeStartLevel.TimeOfDay)
                                                            if (item.Candle[thirdCandle].High <=
                                                                item.Candle[secondCandle].High &&
                                                                item.Candle[thirdCandle].High >=
                                                                item.Candle[secondCandle].High -
                                                                grItem.ThirdBarDeviation &&
                                                                Math.Abs(item.Candle[secondCandle].High -
                                                                         item.Candle[i - 2].High) < 0.000001)
                                                            {
                                                                _method(
                                                                    string.Format(
                                                                        "Условия для входа в шорт по паттерну №2 (2и3 low отдельно от 1 ). Время третьей свечи {0} , High={1}, Время второй свечи {2} , High={3}, Время первой свечи {4} , High={5} "
                                                                        , item.Candle[thirdCandle].DateTime,
                                                                        item.Candle[thirdCandle].High,
                                                                        item.Candle[secondCandle].DateTime,
                                                                        item.Candle[secondCandle].High,
                                                                        item.Candle[i - 2].DateTime,
                                                                        item.Candle[i - 2].High));
                                                                LimitOrMarketOrderForOpenPosition(grItem,
                                                                    item.Candle[curCandle].Open,
                                                                    item.Candle[secondCandle].High,
                                                                    Cfg.Sell);
                                                                TimeOpenFix(grItem, item, curCandle);
                                                                grItem.ListLevel.Add(item.Candle[thirdCandle].High);
                                                                grItem.TimeAttemptOpenPoz =
                                                                    item.Candle[thirdCandle].DateTime;
                                                                if (!String.IsNullOrEmpty(Properties.Settings.Default.SoundOpenPoz))
                                                                    PlaySound(Properties.Settings.Default.SoundOpenPoz);
                                                                return;
                                                            }

                                                    #endregion

                                                    #region Вариация №2 (1и2 отдельно от 3)

                                                    //Условия для входа в лонг
                                                    if (grItem.Patterns.Contains(Cfg.Pattern22Long))
                                                        if (item.Candle[i - 2].DateTime.TimeOfDay >
                                                            grItem.TimeStartLevel.TimeOfDay)
                                                            if (
                                                                Math.Abs(item.Candle[thirdCandle].Low -
                                                                         item.Candle[i - 1].Low) < 0.000001 &&
                                                                Math.Abs(item.Candle[i - 1].Low - item.Candle[i - 2].Low) <
                                                                0.000001)
                                                            {
                                                                _method(
                                                                    string.Format(
                                                                        "Условия для входа в лонг по паттерну №2 (1и2 отдельно от 3). Время третьей свечи {0} , Low={1}, Время второй свечи {2} , Low={3}, Время первой свечи {4} , Low={5} "
                                                                        , item.Candle[thirdCandle].DateTime,
                                                                        item.Candle[thirdCandle].Low,
                                                                        item.Candle[i - 1].DateTime,
                                                                        item.Candle[i - 1].Low,
                                                                        item.Candle[i - 2].DateTime,
                                                                        item.Candle[i - 2].Low));
                                                                LimitOrMarketOrderForOpenPosition(grItem,
                                                                    item.Candle[curCandle].Open, item.Candle[i - 2].Low,
                                                                    Cfg.Buy);
                                                                TimeOpenFix(grItem, item, curCandle);
                                                                grItem.ListLevel.Add(item.Candle[thirdCandle].Low);
                                                                grItem.TimeAttemptOpenPoz =
                                                                    item.Candle[thirdCandle].DateTime;
                                                                if (!String.IsNullOrEmpty(Properties.Settings.Default.SoundOpenPoz))
                                                                    PlaySound(Properties.Settings.Default.SoundOpenPoz);
                                                                return;
                                                            }

                                                    //Условия для входа в шорт
                                                    if (grItem.Patterns.Contains(Cfg.Pattern22Short))
                                                        if (item.Candle[i - 2].DateTime.TimeOfDay >
                                                            grItem.TimeStartLevel.TimeOfDay)
                                                            if (
                                                                Math.Abs(item.Candle[thirdCandle].High -
                                                                         item.Candle[i - 1].High) < 0.000001 &&
                                                                Math.Abs(item.Candle[i - 1].High -
                                                                         item.Candle[i - 2].High) < 0.000001)
                                                            {
                                                                _method(
                                                                    string.Format(
                                                                        "Условия для входа в шорт по паттерну №2 (1и2 отдельно от 3 ). Время третьей свечи {0} , High={1}, Время второй свечи {2} , High={3}, Время первой свечи {4} , High={5} "
                                                                        , item.Candle[thirdCandle].DateTime,
                                                                        item.Candle[thirdCandle].High,
                                                                        item.Candle[i - 1].DateTime,
                                                                        item.Candle[i - 1].High,
                                                                        item.Candle[i - 2].DateTime,
                                                                        item.Candle[i - 2].High));
                                                                LimitOrMarketOrderForOpenPosition(grItem,
                                                                    item.Candle[curCandle].Open, item.Candle[i - 2].High,
                                                                    Cfg.Sell);
                                                                TimeOpenFix(grItem, item, curCandle);
                                                                grItem.ListLevel.Add(item.Candle[thirdCandle].High);
                                                                grItem.TimeAttemptOpenPoz =
                                                                    item.Candle[thirdCandle].DateTime;
                                                                if (!String.IsNullOrEmpty(Properties.Settings.Default.SoundOpenPoz))
                                                                    PlaySound(Properties.Settings.Default.SoundOpenPoz);
                                                                return;
                                                            }

                                                    #endregion

                                                    #endregion

                                                    #region Pattern #3

                                                    #region Вариация №1 (1 high 2 low 3 low вместе)

                                                    //Условия для входа в лонг
                                                    if (grItem.Patterns.Contains(Cfg.Pattern31Long))
                                                        if (item.Candle[thirdCandle].Low >=
                                                            item.Candle[secondCandle].Low &&
                                                            item.Candle[thirdCandle].Low <=
                                                            item.Candle[secondCandle].Low + grItem.ThirdBarDeviation &&
                                                            Math.Abs(item.Candle[secondCandle].Low -
                                                                     item.Candle[firstCandle].High) < 0.000001)
                                                        {
                                                            _method(
                                                                string.Format(
                                                                    "Условия для входа в лонг по паттерну №3 (1 high 2 low 3 low вместе). Время третьей свечи {0} , Low={1}, Время второй свечи {2} , Low={3}, Время первой свечи {4} , Hgih={5} "
                                                                    , item.Candle[thirdCandle].DateTime,
                                                                    item.Candle[thirdCandle].Low,
                                                                    item.Candle[secondCandle].DateTime,
                                                                    item.Candle[secondCandle].Low,
                                                                    item.Candle[firstCandle].DateTime,
                                                                    item.Candle[firstCandle].High));
                                                            LimitOrMarketOrderForOpenPosition(grItem,
                                                                item.Candle[curCandle].Open,
                                                                item.Candle[secondCandle].Low,
                                                                Cfg.Buy);
                                                            TimeOpenFix(grItem, item, curCandle);
                                                            grItem.ListLevel.Add(item.Candle[thirdCandle].Low);
                                                            grItem.TimeAttemptOpenPoz =
                                                                item.Candle[thirdCandle].DateTime;
                                                            if (!String.IsNullOrEmpty(Properties.Settings.Default.SoundOpenPoz))
                                                                PlaySound(Properties.Settings.Default.SoundOpenPoz);
                                                            return;
                                                        }

                                                    //Условия для входа в шорт
                                                    if (grItem.Patterns.Contains(Cfg.Pattern31Short))
                                                        if (item.Candle[thirdCandle].High <=
                                                            item.Candle[secondCandle].High &&
                                                            item.Candle[thirdCandle].High >=
                                                            item.Candle[secondCandle].High - grItem.ThirdBarDeviation &&
                                                            Math.Abs(item.Candle[secondCandle].High -
                                                                     item.Candle[firstCandle].Low) < 0.000001)
                                                        {
                                                            _method(
                                                                string.Format(
                                                                    "Условия для входа в шорт по паттерну №3 (1 low 2 High 3 High вместе). Время третьей свечи {0} , High={1}, Время второй свечи {2} , High={3}, Время первой свечи {4} , Low={5} "
                                                                    , item.Candle[thirdCandle].DateTime,
                                                                    item.Candle[thirdCandle].High,
                                                                    item.Candle[secondCandle].DateTime,
                                                                    item.Candle[secondCandle].High,
                                                                    item.Candle[firstCandle].DateTime,
                                                                    item.Candle[firstCandle].Low));
                                                            LimitOrMarketOrderForOpenPosition(grItem,
                                                                item.Candle[curCandle].Open,
                                                                item.Candle[secondCandle].High,
                                                                Cfg.Sell);
                                                            TimeOpenFix(grItem, item, curCandle);
                                                            grItem.ListLevel.Add(item.Candle[thirdCandle].High);
                                                            grItem.TimeAttemptOpenPoz =
                                                                item.Candle[thirdCandle].DateTime;
                                                            if (!String.IsNullOrEmpty(Properties.Settings.Default.SoundOpenPoz))
                                                                PlaySound(Properties.Settings.Default.SoundOpenPoz);
                                                            return;

                                                        }

                                                    #endregion

                                                    #region Вариация №2 (1и2 low 3 high вместе)

                                                    //Условия для входа в лонг
                                                    //if (item.Candle[thirdCandle].High == item.Candle[secondCandle].Low &&

                                                    //    Math.Abs(item.Candle[secondCandle].Low - item.Candle[firstCandle].Low) < 0.000001)
                                                    //{
                                                    //    _method(
                                                    //        string.Format(
                                                    //            "Условия для входа в лонг по паттерну №3 (1и2 low 3 high вместе). Время третьей свечи {0} , High={1}, Время второй свечи {2} , Low={3}, Время первой свечи {4} , Low={5} "
                                                    //            , item.Candle[thirdCandle].DateTime,
                                                    //            item.Candle[thirdCandle].High,
                                                    //            item.Candle[secondCandle].DateTime,
                                                    //            item.Candle[secondCandle].Low,
                                                    //            item.Candle[firstCandle].DateTime,
                                                    //            item.Candle[firstCandle].Low));
                                                    //    LimitOrMarketOrderForOpenPosition(grItem,
                                                    //        item.Candle[curCandle].Open, item.Candle[secondCandle].Low,
                                                    //        Cfg.Buy);
                                                    //    grItem.ListLevel.Add(item.Candle[thirdCandle].High);
                                                    //    return;
                                                    //}

                                                    ////Условия для входа в шорт
                                                    //if (item.Candle[thirdCandle].Low == item.Candle[secondCandle].High &&

                                                    //    Math.Abs(item.Candle[secondCandle].High - item.Candle[firstCandle].High) < 0.000001)
                                                    //{
                                                    //    _method(
                                                    //        string.Format(
                                                    //            "Условия для входа в шорт по паттерну №3 (1 High 2 High 3 Low вместе). Время третьей свечи {0} , Low={1}, Время второй свечи {2} , High={3}, Время первой свечи {4} , High={5} "
                                                    //            , item.Candle[thirdCandle].DateTime,
                                                    //            item.Candle[thirdCandle].Low,
                                                    //            item.Candle[secondCandle].DateTime,
                                                    //            item.Candle[secondCandle].High,
                                                    //            item.Candle[firstCandle].DateTime,
                                                    //            item.Candle[firstCandle].High));
                                                    //    LimitOrMarketOrderForOpenPosition(grItem,
                                                    //        item.Candle[curCandle].Open, item.Candle[secondCandle].High,
                                                    //        Cfg.Sell);
                                                    //    grItem.ListLevel.Add(item.Candle[thirdCandle].Low);
                                                    //    return;
                                                    //}

                                                    #endregion

                                                    #region Вариация №3 (2и3 low отдельно от 1 high)

                                                    //Условия для входа в лонг
                                                    if (grItem.Patterns.Contains(Cfg.Pattern32Long))
                                                        if (item.Candle[i - 2].DateTime.TimeOfDay >
                                                            grItem.TimeStartLevel.TimeOfDay)
                                                            if (item.Candle[thirdCandle].Low >=
                                                                item.Candle[secondCandle].Low &&
                                                                item.Candle[thirdCandle].Low <=
                                                                item.Candle[secondCandle].Low + grItem.ThirdBarDeviation &&
                                                                Math.Abs(item.Candle[secondCandle].Low -
                                                                         item.Candle[i - 2].High) < 0.000001)
                                                            {
                                                                _method(
                                                                    string.Format(
                                                                        "Условия для входа в лонг по паттерну №3 (2и3 low отдельно от 1 high). Время третьей свечи {0} , Low={1}, Время второй свечи {2} , Low={3}, Время первой свечи {4} , Hgih={5} "
                                                                        , item.Candle[thirdCandle].DateTime,
                                                                        item.Candle[thirdCandle].Low,
                                                                        item.Candle[secondCandle].DateTime,
                                                                        item.Candle[secondCandle].Low,
                                                                        item.Candle[i - 2].DateTime,
                                                                        item.Candle[i - 2].High));
                                                                LimitOrMarketOrderForOpenPosition(grItem,
                                                                    item.Candle[curCandle].Open,
                                                                    item.Candle[secondCandle].Low,
                                                                    Cfg.Buy);
                                                                TimeOpenFix(grItem, item, curCandle);
                                                                grItem.ListLevel.Add(item.Candle[thirdCandle].Low);
                                                                grItem.TimeAttemptOpenPoz =
                                                                    item.Candle[thirdCandle].DateTime;
                                                                if (!String.IsNullOrEmpty(Properties.Settings.Default.SoundOpenPoz))
                                                                    PlaySound(Properties.Settings.Default.SoundOpenPoz);
                                                                return;

                                                            }

                                                    //Условия для входа в шорт
                                                    if (grItem.Patterns.Contains(Cfg.Pattern32Short))
                                                        if (item.Candle[i - 2].DateTime.TimeOfDay >
                                                            grItem.TimeStartLevel.TimeOfDay)
                                                            if (item.Candle[thirdCandle].High <=
                                                                item.Candle[secondCandle].High &&
                                                                item.Candle[thirdCandle].High >=
                                                                item.Candle[secondCandle].High -
                                                                grItem.ThirdBarDeviation &&
                                                                Math.Abs(item.Candle[secondCandle].High -
                                                                         item.Candle[i - 2].Low) < 0.000001)
                                                            {
                                                                _method(
                                                                    string.Format(
                                                                        "Условия для входа в шорт по паттерну №3 (2и3 High отдельно от 1 Low). Время третьей свечи {0} , High={1}, Время второй свечи {2} , High={3}, Время первой свечи {4} , Low={5} "
                                                                        , item.Candle[thirdCandle].DateTime,
                                                                        item.Candle[thirdCandle].High,
                                                                        item.Candle[secondCandle].DateTime,
                                                                        item.Candle[secondCandle].High,
                                                                        item.Candle[i - 2].DateTime,
                                                                        item.Candle[i - 2].Low));
                                                                LimitOrMarketOrderForOpenPosition(grItem,
                                                                    item.Candle[curCandle].Open,
                                                                    item.Candle[secondCandle].High,
                                                                    Cfg.Sell);
                                                                grItem.ListLevel.Add(item.Candle[thirdCandle].High);
                                                                TimeOpenFix(grItem, item, curCandle);
                                                                grItem.TimeAttemptOpenPoz =
                                                                    item.Candle[thirdCandle].DateTime;
                                                                if (!String.IsNullOrEmpty(Properties.Settings.Default.SoundOpenPoz))
                                                                    PlaySound(Properties.Settings.Default.SoundOpenPoz);
                                                                return;
                                                            }

                                                    #endregion

                                                    #endregion
                                                }
                                        }

                                        #endregion
                                    }


                            }

                            //Закрытие позиции в конце дня
                            if (grItem.TimeClosePoz.TimeOfDay <= item.Candle[curCandle].DateTime.TimeOfDay)
                            //&& GrItem.TradeList[0].CloseStatusOrder == null нужно думать как фильтровать, возможно через булевую переменную
                            {
                                if (grItem.TradeList.Count > 0)
                                {
                                    if (grItem.TradeList[0].CloseStatusOrder == Cfg.Active &&
                                        grItem.CloseEndDay == false)
                                    {
                                        MainWindow.OConn.SendCommand(
                                            data.TransaqCommand.CancelOrder(grItem.TradeList[0].CloseID));
                                        _method(
                                            string.Format(
                                                "Закрытие по времени закрытии. Снятие ордера на закрытие позции"));
                                    }
                                    if (grItem.TradeList[0].OpenStatusOrder == Cfg.Active && grItem.CloseEndDay == false)
                                    {
                                        MainWindow.OConn.SendCommand(
                                            data.TransaqCommand.CancelOrder(grItem.TradeList[0].OpenID));
                                        _method(
                                            string.Format(
                                                "Закрытие по времени закрытии. Снятие ордера на открытие позции"));
                                    }
                                    grItem.CloseEndDay = true;
                                    if (grItem.CloseEndDay && grItem.TradeList[0].CloseStatusOrder == Cfg.Cancel &&
                                        grItem.CurPosition != 0)
                                    {
                                        CloseMarketPosition(grItem);
                                        grItem.TradeList[0].CloseStatusOrder = Cfg.Unknown;
                                        grItem.TradeList[0].CloseDate = DateTime.Now;
                                        _method(
                                            string.Format("Закрытие по времени закрытии. Закрытие позиции по рынку"));
                                    }
                                }
                            }


                        }
                    }

                   
                }
            }

            if (grItem.TradeList.Count > 0)
            {
                //снятие лимитной заявки на открытие позиции, при уходе ценаы на заданную величину
                if (grItem.LastPrice >= grItem.LevelPrice + grItem.KillOrderPoint &&
                    grItem.TradeList[0].OpenOperation == Cfg.Buy && grItem.TradeList[0].OpenStatusOrder == Cfg.Active)
                {
                    MainWindow.OConn.SendCommand(
                        data.TransaqCommand.CancelOrder(grItem.TradeList[0].OpenID));
                    _method(
                        string.Format("Снятие лимитной заявки на открытие при уходе цена на заданную величину от уровня"));
                }
                if (grItem.LastPrice <= grItem.LevelPrice - grItem.KillOrderPoint &&
                    grItem.TradeList[0].OpenOperation == Cfg.Sell && grItem.TradeList[0].OpenStatusOrder == Cfg.Active)
                {
                    MainWindow.OConn.SendCommand(
                        data.TransaqCommand.CancelOrder(grItem.TradeList[0].OpenID));
                    _method(
                        string.Format("Снятие лимитной заявки на открытие при уходе цена на заданную величину от уровня"));
                }
            }

            //Выставление стопов и профитон на закрытие позиции
            //if (curTime > GrItem.TimeStartLevel.TimeOfDay && curTime <= GrItem.TimeStopLevel.TimeOfDay)
            if (grItem.CurPosition != 0 && grItem.TradeList.Count > 0)
            {
                #region Безубыток, прверяем можем ли мы переносить его
                if (grItem.TradeList[0].OpenOperation == Cfg.Buy)
                    if (grItem.LastPrice >= grItem.LevelPrice + grItem.Breakeven)
                        grItem.BreakevenFlag = true;

                if (grItem.TradeList[0].OpenOperation == Cfg.Sell)
                    if (grItem.LastPrice <= grItem.LevelPrice - grItem.Breakeven)
                        grItem.BreakevenFlag = true;

                #endregion


                if (grItem.TradeList[0].StopLimitCloseStatusOrder == null || (grItem.TradeList[0].StopLimitCloseStatusOrder == Cfg.Cancel && grItem.BreakevenFlag))
                {
                    SendStopOrder(grItem);
                }
            }
        }

        /// <summary>
        /// Фиксация времени входа в позицию, чтоб за один интервал свечи исключить двойной вход в позицию
        /// </summary>
        /// <param name="grItem"></param>
        /// <param name="item"></param>
        /// <param name="curCandle"></param>
        private static void TimeOpenFix(GechikRobotItem grItem, Candles item, int curCandle)
        {
            grItem.LastDateTimeCandel = new DateTime(item.Candle[curCandle].DateTime.Year,
                item.Candle[curCandle].DateTime.Month, item.Candle[curCandle].DateTime.Day,
                item.Candle[curCandle].DateTime.Hour, item.Candle[curCandle].DateTime.Minute, 0);
        }

        /// <summary>
        /// Алгоритм работы робота в режиме советника
        /// </summary>
        public void SovetnikRobot()
        {
        }

        /// <summary>
        /// Отправка транзакции на зактрытие позиции
        /// </summary>
        /// <param name="grItem"></param>
        public void CloseMarketPosition(GechikRobotItem grItem)
        {
            if (data.GetBoard(grItem.Instrument) != "FUT")
            {
                grItem.TradeList[0].CloseID =
                    Convert.ToInt32(
                        (XElement.Parse(
                            MainWindow.OConn.SendCommand(data.TransaqCommand.NewOrderBoardSeccode(true, true, 0,
                                data.GetBoard(grItem.Instrument), grItem.Instrument, grItem.ClientCode,
                                Math.Abs(grItem.Quantity), 0, grItem.Quantity > 0 ? 'B' : 'S', "")))).LastAttribute
                            .Value);
            }
            else
            {
                grItem.TradeList[0].CloseID =
                    Convert.ToInt32(
                        (XElement.Parse(
                            MainWindow.OConn.SendCommand(data.TransaqCommand.NewOrderBoardSeccode(true, false, 0,
                                data.GetBoard(grItem.Instrument), grItem.Instrument, grItem.ClientCode,
                                Math.Abs(grItem.Quantity), 0, grItem.Quantity > 0 ? 'B' : 'S', "")))).LastAttribute
                            .Value);

            }
            grItem.TradeList[0].CloseStatusOrder = Cfg.Unknown;
        }


        #region Работа со стоп-заявками
        /// <summary>
        /// Отрпавка транзакций по стоп-лимит
        /// </summary>
        /// <param name="grItem"></param>
        public void SendStopOrder(GechikRobotItem grItem)
        {
            if (grItem.TradeList[0].OpenOperation == Cfg.Buy)
            {
                if (data.GetBoard(grItem.Instrument) != "FUT")
                {
                    grItem.TradeList[0].StopLimitCloseID =
                        Convert.ToInt32(
                            (XElement.Parse(
                                MainWindow.OConn.SendCommand(data.TransaqCommand.NewStopOrderBoardSeccode(true,
                                    true, 0, data.GetBoard(grItem.Instrument), grItem.Instrument,
                                    grItem.ClientCode,
                                    Math.Abs(grItem.Quantity), grItem.TradeList[0].OpenOperation == Cfg.Sell ? 'B' : 'S',
                                    "",
                                    GetStopPrice(grItem), 0, GetTakeProfit(grItem), 0, 0)))).LastAttribute.Value);
                }
                else
                {
                    grItem.TradeList[0].StopLimitCloseID =
                        Convert.ToInt32(
                            (XElement.Parse(
                                MainWindow.OConn.SendCommand(data.TransaqCommand.NewStopOrderBoardSeccode(true,
                                    false, 0, data.GetBoard(grItem.Instrument), grItem.Instrument,
                                    grItem.ClientCode,
                                    Math.Abs(grItem.Quantity), grItem.TradeList[0].OpenOperation == Cfg.Sell ? 'B' : 'S',
                                    "",
                                    GetStopPrice(grItem), 0, GetTakeProfit(grItem), 0, 0)))).LastAttribute.Value);
                }
                grItem.TradeList[0].StopLimitCloseStatusOrder = Cfg.Unknown;
                grItem.TradeList[0].StopLimitClosePrice = GetStopPrice(grItem);
                _method(
                    string.Format("Выставление стоп-заявки для позиции лонг. "));
            }
            if (grItem.TradeList[0].OpenOperation == Cfg.Sell)
            {

                grItem.TradeList[0].StopLimitCloseID =
                    Convert.ToInt32(
                        (XElement.Parse(
                            MainWindow.OConn.SendCommand(data.TransaqCommand.NewStopOrderBoardSeccode(true,
                                true, 0, data.GetBoard(grItem.Instrument), grItem.Instrument,
                                grItem.ClientCode,
                                Math.Abs(grItem.Quantity), grItem.TradeList[0].OpenOperation == Cfg.Sell ? 'B' : 'S', "",
                                GetStopPrice(grItem), 0, GetTakeProfit(grItem), 0, 0)))).LastAttribute.Value);
                grItem.TradeList[0].StopLimitCloseStatusOrder = Cfg.Unknown;
                grItem.TradeList[0].StopLimitClosePrice = GetStopPrice(grItem);
                _method(
                    string.Format("Выставление стоп-заявки для позиции шорт. "));
            }
        }

        /// <summary>
        /// Определение стоп-цены для стоп-заявки
        /// </summary>
        /// <param name="grItem"></param>
        /// <returns></returns>
        public double GetStopPrice(GechikRobotItem grItem)
        {
            if (grItem.TradeList[0].OpenOperation == Cfg.Buy)
            {
                if (grItem.BreakevenFlag == false)
                    return Math.Round(grItem.LevelPrice - grItem.StopLimiOtstup, _accuraccy);
                return Math.Round(grItem.LevelPrice, _accuraccy);
            }
            if (grItem.TradeList[0].OpenOperation == Cfg.Sell)
            {
                if (grItem.BreakevenFlag == false)
                    return Math.Round(grItem.LevelPrice + grItem.StopLimiOtstup, _accuraccy);
                return Math.Round(grItem.LevelPrice, _accuraccy);
            }

            return 0;
        }

        /// <summary>
        /// Определение стоп-цены для стоп-заявки
        /// </summary>
        /// <param name="grItem"></param>
        /// <returns></returns>
        public double GetTakeProfit(GechikRobotItem grItem)
        {
            if (grItem.TradeList[0].OpenOperation == Cfg.Buy)
            {
                return Math.Round(grItem.LevelPrice + grItem.Profit, _accuraccy);
            }
            if (grItem.TradeList[0].OpenOperation == Cfg.Sell)
            {
                return Math.Round(grItem.LevelPrice - grItem.Profit, _accuraccy);
            }

            return 0;
        }
        #endregion

        #region Работа с заявками

        /// <summary>
        /// Выбор опреации рыночная или лимитная, в зависимости от отркытия четвертой свечи
        /// </summary>
        /// <param name="grItem"></param>
        /// <param name="priceFourCandle"></param>
        /// <param name="priceLevel"></param>
        /// <param name="oper"></param>
        private void LimitOrMarketOrderForOpenPosition(GechikRobotItem grItem, double priceFourCandle, double priceLevel, string oper)
        {
            grItem.LevelPrice = priceLevel;

            if (oper == Cfg.Buy)
            {
                if (priceFourCandle > Math.Round(priceLevel + grItem.MaxExcess, _accuraccy))
                {
                    _method(
                        string.Format("Открытие лимитным ордером. Цена текущей свечи: " + priceFourCandle + " Уровень + превышение = " + (Math.Round(priceLevel + grItem.MaxExcess, _accuraccy))));
                    OpenOrderNew(grItem, oper, Math.Round(priceLevel + grItem.MaxExcess, _accuraccy), false);

                }
                else
                {
                    _method(
                    string.Format("Открытие рыночным ордером. Цена текущей свечи: " + priceFourCandle + " Уровень + превышение = " + (Math.Round(priceLevel + grItem.MaxExcess, _accuraccy))));
                    OpenOrderNew(grItem, oper, Math.Round(priceLevel + grItem.MaxExcess, _accuraccy), true);

                }
            }
            else
            {
                if (priceFourCandle < Math.Round(priceLevel - grItem.MaxExcess, _accuraccy))
                {
                    _method(
                        string.Format("Открытие лимитным ордером. Цена текущей свечи: " + priceFourCandle + " Уровень - превышение = " + (Math.Round(priceLevel - grItem.MaxExcess, _accuraccy))));
                    OpenOrderNew(grItem, oper, Math.Round(priceLevel - grItem.MaxExcess, _accuraccy), false);

                }
                else
                {
                    _method(
                        string.Format("Открытие рыночным ордером. Цена текущей свечи: " + priceFourCandle + " Уровень - превышение = " + (Math.Round(priceLevel - grItem.MaxExcess, _accuraccy))));
                    OpenOrderNew(grItem, oper, Math.Round(priceLevel - grItem.MaxExcess, _accuraccy), true);

                }
            }
        }


        /// <summary>
        /// Добавление новой заявки на открытие
        /// </summary>
        /// <param name="item"></param>
        /// <param name="oper"></param>
        /// <param name="price"></param>
        /// <param name="marketOper">тип заявки рыночная или лимитная</param>
        private void OpenOrderNew(GechikRobotItem item, string oper, double price, bool marketOper)
        {

            if (item.TradeList == null)
                item.TradeList = new System.Collections.ObjectModel.ObservableCollection<TradesOpen>();

            if (oper == Cfg.Buy)
                AddOrderOpenTotradeList(item, price, oper == "Купля" ? 'B' : 'S', marketOper);

            if (oper == Cfg.Sell)
                AddOrderOpenTotradeList(item, price, oper == "Купля" ? 'B' : 'S', marketOper);
        }

        /// <summary>
        /// выставляем заявкку на откртыие позиции и записываем в лист
        /// </summary>
        /// <param name="item"></param>
        /// <param name="priceOpen"></param>
        /// <param name="oper"></param>
        /// <param name="marketOper"></param>
        private void AddOrderOpenTotradeList(GechikRobotItem item, double priceOpen, char oper, bool marketOper)
        {
            item.AddCurrentAttempt = false;
            TradesOpen tradesOpen = new TradesOpen();
            tradesOpen.OpenDate = DateTime.Now;
            try
            {

                if (data.GetBoard(item.Instrument) != "FUT")
                {
                    //var result = MainWindow.OConn.SendCommand(data.TransaqCommand.NewOrderBoardSeccode(marketOper, true,
                    //    0,
                    //    data.GetBoard(item.Instrument), item.Instrument, item.ClientCode, item.Quantity,
                    //    priceOpen, oper, ""));
                    //var dfdf = XElement.Parse(result).LastAttribute;

                    //tradesOpen.OpenID =
                    //    Convert.ToInt32(dfdf);

                    //_method(string.Format(result));

                    var df = MainWindow.OConn.SendCommand(data.TransaqCommand.NewOrderBoardSeccode(marketOper, true,
                        0,
                        data.GetBoard(item.Instrument), item.Instrument, item.ClientCode, item.Quantity,
                        priceOpen, oper, ""));
                    tradesOpen.OpenID =
                        Convert.ToInt32(
                            (XElement.Parse(df
                                )).LastAttribute.Value);
                }
                else
                {
                    tradesOpen.OpenID =
                        Convert.ToInt32(
                            (XElement.Parse(
                                MainWindow.OConn.SendCommand(data.TransaqCommand.NewOrderBoardSeccode(marketOper, false,
                                    0,
                                    data.GetBoard(item.Instrument), item.Instrument, item.ClientCode, item.Quantity,
                                    priceOpen, oper, "")))).LastAttribute.Value);
                }
                if (oper == 'B')
                {
                    tradesOpen.OpenOperation = "Купля";
                    tradesOpen.OpenPriceOrder = priceOpen;
                    tradesOpen.OpenQuantity = item.Quantity;
                }
                else
                {
                    tradesOpen.OpenOperation = "Продажа";
                    tradesOpen.OpenPriceOrder = priceOpen;
                    tradesOpen.OpenQuantity = -item.Quantity;
                }

                tradesOpen.OpenStatusOrder = Cfg.Unknown;
                item.TradeList.Add(tradesOpen);
            }
            catch
            {
            }
        }
        #endregion



        /// <summary>
        /// Преобразование секунд в текущее время
        /// </summary>
        /// <param name="seconds"></param>
        /// <returns></returns>
        private TimeSpan TimeConvertor(int seconds)
        {
            int hour = seconds / 60 / 60;
            int minutes = (seconds - 60 * 60 * hour) / 60;
            int second = seconds - 60 * 60 * hour - minutes * 60;
            TimeSpan result = new TimeSpan(hour, minutes, second);

            return result;
        }

        /// <summary>
        /// блок проверки заявок на изменение статуса и баланса
        /// </summary>
        /// <param name="ld"></param>
        public void GetStatusAndBalance(GechikRobotItem ld)
        {
            try
            {
                var orderMassiv = data.GetOrderListAllforInstrunemts(ld.Account, ld.ClientCode, ld.Instrument);

                for (int i = 0; i < ld.TradeList.Count; i++)
                {
                    if (ld.TradeList.Count == 0)
                        break;

                    #region Проверка объема
                    foreach (var item2 in orderMassiv)
                    {
                        //проверка статусов на изменение заявок на открытие пока балансе не равен выставленному числу
                        //if (item2.Transactionid == ld.TradeList[i].OpenID)// && ld.TradeList[i].OpenBalance != Math.Abs(ld.TradeList[i].OpenQuantity))
                        if (item2.Orderno == ld.TradeList[i].OpenNumberOrder)// && ld.TradeList[i].OpenBalance != Math.Abs(ld.TradeList[i].OpenQuantity))
                        {
                            ld.TradeList[i].OpenID = item2.Transactionid;
                            ld.TradeList[i].OpenStatusOrder = item2.Status;
                            if (Math.Abs(ld.TradeList[i].OpenQuantity) == item2.Quantity)
                                ld.TradeList[i].OpenBalance = item2.Quantity - item2.Balance;
                            else
                            {
                                //если заявка снята либо в конце сеесии либо врунчую и надо выставляться на меньший объем
                                if (ld.TradeList[i].OpenQuantity > ld.TradeList[i].OpenBalance + item2.Balance)
                                    ld.TradeList[i].OpenBalance = ld.TradeList[i].OpenQuantity - item2.Balance;
                                if (ld.TradeList[i].OpenQuantity == ld.TradeList[i].OpenBalance + item2.Balance && item2.Balance == 0)
                                    ld.TradeList[i].OpenBalance = ld.TradeList[i].OpenQuantity;
                            }
                        }

                        //проверка статусов на изменение заявок на закрытие позиции пока балансе не равен выставленному числу
                        if (ld.TradeList[i].OpenBalance == ld.TradeList[i].OpenQuantity)
                            if (item2.Orderno == ld.TradeList[i].CloseNumberOrder && ld.TradeList[i].CloseBalance != ld.TradeList[i].CloseQuantity)
                            {
                                ld.TradeList[i].CloseID = item2.Transactionid;
                                //ld.TradeList[i].CloseNumberOrder = item2.Orderno;
                                ld.TradeList[i].CloseStatusOrder = item2.Status;
                                if (ld.TradeList[i].CloseQuantity == item2.Quantity)
                                    ld.TradeList[i].CloseBalance = item2.Quantity - item2.Balance;
                                else
                                {
                                    //если заявка снята либо в конце сеесии либо врунчую и надо выставляться на меньший объем
                                    if (ld.TradeList[i].CloseQuantity > ld.TradeList[i].CloseBalance + item2.Balance)
                                        ld.TradeList[i].CloseBalance = ld.TradeList[i].CloseQuantity - item2.Balance;
                                    if (ld.TradeList[i].CloseQuantity == ld.TradeList[i].CloseBalance + item2.Balance && item2.Balance == 0)
                                        ld.TradeList[i].CloseBalance = ld.TradeList[i].CloseQuantity;
                                }
                            }
                    }
                    #endregion

                    //если в течении 10 секунд заявка не появилась в системе удалить ее, или ее сняли в ручном формате и не было исполнения, или удаляетс из списка если заявка не определена и уже ее смотрят в другом дне. На закрытие позиции
                    if ((ld.TradeList[i].CloseDate.TimeOfDay + new TimeSpan(0, 0, 30) <= DateTime.Now.TimeOfDay && ld.TradeList[i].CloseStatusOrder == Cfg.Unknown)
                        || (ld.TradeList[i].CloseDate.Date != DateTime.Now.Date && (ld.TradeList[i].CloseStatusOrder == Cfg.Unknown)))
                    {
                        _method(
                              string.Format("Удаляем информацию о закрытии позиции. Т.к. данной заявки нет "));
                        ld.TradeList.Remove(ld.TradeList[i]);
                        if (i > 0)
                            i--;
                        if (i == 0)
                            break;
                    }

                    //если при переходе в другой день, заявки на закрытие остались активными, то сбросить их в статус null
                    if (ld.TradeList[i].CloseDate.Date != DateTime.Now.Date && ld.TradeList[i].CloseStatusOrder == Cfg.Active)
                        ld.TradeList[i].CloseStatusOrder = null;

                    //если в течении 10 секунд заявка не появилась в системе удалить ее, или ее сняли в ручном формате и не было исполнения, или удаляетс из списка если заявка не определена и уже ее смотрят в другом дне
                    if ((ld.TradeList[i].OpenDate.TimeOfDay + new TimeSpan(0, 0, 30) <= DateTime.Now.TimeOfDay && ld.TradeList[i].OpenStatusOrder == Cfg.Unknown)
                        || (ld.TradeList[i].OpenStatusOrder == Cfg.Cancel && ld.TradeList[i].OpenBalance == 0)
                        || (ld.TradeList[i].OpenDate.Date != DateTime.Now.Date && (ld.TradeList[i].OpenStatusOrder == Cfg.Unknown || ld.TradeList[i].OpenStatusOrder == Cfg.Active))
                        )
                    {
                        _method(
                            string.Format("Удаляем информацию об открытии позиции. Т.к. информация о ней не пришла из системы"));
                        if (ld.TradeList[i].OpenBalance == 0)
                        {
                            ld.TradeList.Remove(ld.TradeList[i]);
                            if (i > 0)
                                i--;
                            if (i == 0)
                                break;
                        }
                        else
                        {
                            ld.TradeList[i].OpenStatusOrder = null;
                        }
                    }

                    if (ld.TradeList[i].OpenStatusOrder == Cfg.Cancel && ld.TradeList[i].OpenBalance != 0)
                    {
                        ld.TradeList[i].OpenStatusOrder = null;
                    }

                    //Заявка на открытие и закрытие исполнились полностью
                    if (ld.TradeList[i].CloseStatusOrder == Cfg.Performed && ld.TradeList[i].OpenQuantity == ld.TradeList[i].OpenBalance &&
                        ld.TradeList[i].CloseStatusOrder == Cfg.Performed && ld.TradeList[i].CloseQuantity == ld.TradeList[i].CloseBalance &&
                        (ld.TradeList[i].StopLimitCloseStatusOrder == Cfg.Cancel || ld.TradeList[i].StopLimitCloseStatusOrder == null) &&
                        (ld.TradeList[i].OrderFromStopLimitCloseStatusOrder == Cfg.Cancel || ld.TradeList[i].OrderFromStopLimitCloseStatusOrder == null)
                        )
                    {
                        _method(
                             string.Format("Удаляем информацию о позиции, т.к. заявка на закрытия исполнилась "));
                        ld.TradeList.Remove(ld.TradeList[i]);
                        if (i > 0)
                            i--;
                        if (i == 0)
                            break;
                    }


                }
            }
            catch
            { }
        }

        /// <summary>
        /// блок проверки стоп-заявок статуса и баланса
        /// </summary>
        /// <param name="ld"></param>
        public void GetStatusAndBalanceStopLimit(GechikRobotItem ld)
        {
            try
            {
                var orderMassiv = data.GetOrderListAllforInstrunemts(ld.Account, ld.ClientCode, ld.Instrument);
                var stopLimitMassiv = data.GetStopOrderListAllforInstrunemts(ld.Account, ld.ClientCode, ld.Instrument);

                //Проверка исполнения заявки типа связанная заявка
                for (int i = 0; i < ld.TradeList.Count; i++)
                {
                    if (ld.TradeList.Count == 0)
                        break;

                    #region стоп лимит
                    foreach (var item2 in stopLimitMassiv)
                    {
                        //проверка статусов на изменение заявок на открытие пока балансе не равен выставленному числу
                        if (item2.Transactionid == ld.TradeList[i].StopLimitCloseID && ld.TradeList[i].StopLimitCloseStatusOrder != Cfg.Cancel && (ld.TradeList[i].StopLimitCloseStatusOrder != Cfg.PerformedProfit || ld.TradeList[i].StopLimitCloseStatusOrder != Cfg.PerformedStop))
                        {
                            ld.TradeList[i].StopLimitCloseStatusOrder = item2.Status;
                        }
                        //Проверка на изменение статуса стоп-заявки
                        if (item2.Transactionid == ld.TradeList[i].StopLimitCloseID)
                        {
                            if (ld.TradeList[i].StopLimitCloseStatusOrder != Cfg.Unknown)
                                ld.TradeList[i].StopLimitCloseStatusOrder = item2.Status;
                            ld.TradeList[i].StopLimitCloseNumberLinkidOrder = item2.Linkedorderno;
                            //если стоп-заявка отвергнута системой выставляем еще раз
                            //if (ld.TradeList[i].StopLimitCloseResult == cfg.REMOVE_FORM_TS)
                            //    ld.TradeList[i].StopLimitCloseStatusOrder = null;
                            //определяем номер заявки выставленной в систему при активации стоп-заявки
                            if (ld.TradeList[i].StopLimitCloseStatusOrder == Cfg.AddToTs || ld.TradeList[i].StopLimitCloseStatusOrder == Cfg.AddToTs)
                                ld.TradeList[i].StopLimitCloseNumberLinkidOrder = item2.Linkedorderno;
                        }
                    }

                    //Проверка на соответстивие ценам
                    if (ld.TradeList[i].StopLimitCloseStatusOrder == Cfg.Active)
                        if (Math.Abs(ld.TradeList[i].StopLimitClosePrice - GetStopPrice(ld)) > 0.000001)
                        {
                            _method(
                                string.Format("Снятие стоп-заявки, цена стоп-заявки изменилась"));
                            MainWindow.OConn.SendCommand(
                                data.TransaqCommand.CancelStopOrder(ld.TradeList[0].StopLimitCloseID));
                        }

                    //если в течении 10 секунд стоп-заявка не появилась в системе удалить ее, или ее сняли в ручном формате и не было исполнения, или удаляетс из списка если заявка не определена и уже ее смотрят в другом дне. На закрытие позиции
                    if ((ld.TradeList[i].StopLimitCloseDate.TimeOfDay + new TimeSpan(0, 0, 30) <= DateTime.Now.TimeOfDay && ld.TradeList[i].StopLimitCloseStatusOrder == Cfg.Unknown)
                        || (ld.TradeList[i].StopLimitCloseDate.Date != DateTime.Now.Date && (ld.TradeList[i].StopLimitCloseStatusOrder == Cfg.Unknown)))
                    {
                        // ld.TradeList[i].StopLimitCloseStatusOrder = null;
                    }
                    #endregion

                    //перевыставляемся если стоп-заявка снята брокером
                    if (ld.TradeList[i].StopLimitCloseStatusOrder == Cfg.BrokerCancel)
                    {
                        ld.TradeList[i].StopLimitCloseStatusOrder = null;
                    }

                    //провереям заявки на выставление
                    if (ld.TradeList[i].StopLimitCloseNumberLinkidOrder != 0 && ld.TradeList[i].StopLimitCloseStatusOrder != Cfg.Unknown)
                    {
                        foreach (var item2 in orderMassiv)
                        {
                            //проверка статусов на изменение заявок на закрытие позиции
                            if (ld.TradeList[i].StopLimitCloseID == item2.Transactionid && ld.TradeList[i].OrderFromStopLimitCloseStatusOrder == null)
                            {
                                ld.TradeList[i].OrderFromStopLimitCloseStatusOrder = item2.Status;
                                ld.TradeList[i].OrderFromStopLimitCloseNumberOrder = item2.Orderno;
                                ld.TradeList[i].OrderFromStopLimitCloseID = item2.Transactionid;
                            }

                            if (ld.TradeList[i].OrderFromStopLimitCloseStatusOrder != null && ld.TradeList[i].OrderFromStopLimitCloseID == item2.Transactionid
                                && ld.TradeList[i].StopLimitCloseNumberLinkidOrder == 0)
                                ld.TradeList[i].OrderFromStopLimitCloseStatusOrder = item2.Status;


                        }
                    }
                    //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! Вот здесь необходимо прописать снятие заявок и стоп-заявок

                    //обнуление текущей позиции трейдлиста, при снятии стоп-заявки и заявки, обычно при переходе через клиринг или на другой день происходт
                    if (ld.TradeList[i].StopLimitCloseStatusOrder == Cfg.PerformedProfit || ld.TradeList[i].StopLimitCloseStatusOrder == Cfg.PerformedStop || ld.TradeList[i].CloseStatusOrder == Cfg.PerformedProfit || ld.TradeList[i].CloseStatusOrder == Cfg.PerformedStop)
                    {
                        if (ld.TradeList[i].StopLimitCloseStatusOrder == Cfg.Active)
                            MainWindow.OConn.SendCommand(data.TransaqCommand.CancelStopOrder(ld.TradeList[0].StopLimitCloseID));
                        if (ld.TradeList[i].OrderFromStopLimitCloseStatusOrder == Cfg.Active)
                            MainWindow.OConn.SendCommand(data.TransaqCommand.CancelStopOrder(ld.TradeList[0].OrderFromStopLimitCloseID));
                        if (ld.TradeList[i].CloseStatusOrder == Cfg.Active)
                            MainWindow.OConn.SendCommand(data.TransaqCommand.CancelStopOrder(ld.TradeList[0].CloseID));

                        if (ld.TradeList[i].StopLimitCloseStatusOrder != Cfg.Active && ld.TradeList[i].OrderFromStopLimitCloseStatusOrder != Cfg.Active && ld.TradeList[i].CloseStatusOrder != Cfg.Active)
                        {
                            if (ld.TradeList[i].StopLimitCloseStatusOrder == Cfg.PerformedProfit) // || ld.TradeList[i].CloseStatusOrder == Cfg.PerformedStop)
                                ld.CurrentAttempt = ld.AttemptAmount;

                            ld.BreakevenFlag = false;
                            ld.TradeList.Remove(ld.TradeList[i]);
                            if (i > 0)
                                i--;
                            if (i == 0)
                                break;
                        }
                    }
                }
            }
            catch
            { }
        }



        /// <summary>
        /// Проигрывание музыки при совершении действия
        /// </summary>
        /// <param name="PathSound"></param>
        private void PlaySound(string PathSound)
        {
            if (gItemTmp.SoundAlert)
            {
                player.Stop();
                player.Open(new Uri(PathSound, UriKind.Relative));
                player.Play();
            }
        }
    }
}
